public class Test {
    /**
     * 认识线程
     * @param args
     *      2.创建线程
     *      3.Thread类及常见方法
     *      4.启动一个线程
     *      5.中断一个线程
     */
    /**
     * 中断(终止)一个线程
     *      1.自定义标记
     *      2.调用interrupt()来通知
     */
    public static void main(String[] args) {
        /**
         * 调用interrupt()来通知
         *      sleep会将标记初始化为执行,所以sleep的catch操作可以自己来进行设置
         */
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;//设置3s后借宿进程
                }
            }
            System.out.println("线程结束");
        });

        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        t.interrupt();//修改标记为true,true为停止
    }
    private static boolean isRunning = true;//一定要是全局变量,不然会发生变量捕获
    public static void main6(String[] args) throws InterruptedException {
        /**
         * 自定义标记
         */
        Thread t = new Thread(() ->{
            while(isRunning) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("线程结束");
        });

        t.start();

        Thread.sleep(3000);
        isRunning = false;//修改线程执行条件,使线程结束
    }
    public static void main5(String[] args) {
        /**
         * 启动一个线程
         *     1.创建任务,重写run...
         *     2.启动线程,调用start()方法->此时线程才启动
         */
    }
    /**
     * Thread类及常见方法
     *      1.Thread常见构造方法
     *      2.Thread几个常见属性
     */
    public static void main4(String[] args) {
        /**
         * Thread的几个常见属性
         *      1.ID -> 方法名:getId()
         *      2.名称 -> getName()
         *      3.状态 -> getState()
         *      4.优先级 -> getPriority(),具体优先级根据系统调度来决定
         *      5.是否后台线程 -> isDaemon()
         *          1.前台线程 -> 如果该进程不结束 java进程不能结束
         *          2.后台线程 -> 即使该进程任在运行 不能阻止java进程结束
         *          3.将前台线程修改为后台线程 -> setDaemon()
         *      6.是否存活 -> isAlive(),存活为true 结束/不存在为false
         *      7.是否被中断 -> isInterrupted()
         */
        //对属性5进行代码实现
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });

        //将该线程变为后台线程,必须在没有启动线程之前进行设置
        t.setDaemon(true);

        t.start();
    }
    public static void main3(String[] args) {
        /**
         *Thread常见构造方法
         *  1.Thread() ->创建线程对象
         *  2.Thread(Runnable target(对象名)) ->通过Runnable对象创建线程对象
         *  3.Thread(String name) ->给线程进行命名(便于查看)
         *  4.Thread(Runnable target(对象名),String name) ->通过Runnable对象创建线程对象,并命名
         */
    }
    /**
     *  创建线程
     * @param args
     *      4.匿名内部类实现Runnable
     *      5.使用lambda表达式
     */
    public static void main2(String[] args) {
        Thread t = new Thread(() -> {
           while(true) {
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t.start();

        while(true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    public static void main1(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();

        while(true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
